package com.qf.index;


import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.volcengine.ark.runtime.model.completion.chat.ChatCompletionRequest;
import com.volcengine.ark.runtime.model.completion.chat.ChatMessage;
import com.volcengine.ark.runtime.model.completion.chat.ChatMessageRole;
import com.volcengine.ark.runtime.service.ArkService;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import okhttp3.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * <dependency>
 * <groupId>com.squareup.okhttp3</groupId>
 * <artifactId>okhttp</artifactId>
 * <version>4.9.3</version>
 * </dependency>
 *
 * <dependency>
 * <groupId>com.alibaba</groupId>
 * <artifactId>fastjson</artifactId>
 * <version>1.2.79</version>
 * </dependency>
 */

/**
 * @Author: 张福垒
 * @Date: 2024/10/08 10:26
 * @Description:
 * @phone: 13864677931
 */
public class TongYiApi {
    /**
     * 这是使用阿里的通义，使用4个账号，区分方法是把自增主键的后两位分为4段，0-24；25-49；50-74；75-99，均分一起跑。
     * 贾新志 2024.12.28
     * Bearer sk-c65ee8baf0c440238e51f74495107da3 公司[1]
     * Bearer sk-68b83bd45df542ada3d7882e116f63f0 JXZ[2]
     * Bearer sk-78636476472d45a1835795ca82c3d7d6 GCR[3]
     * Bearer sk-06a0675779c944b6a4d5b893cb3cc89a ZFL[4]
     */

    public static void main(String[] args) {
        // 测试的文本
        String user = "Bearer sk-06a0675779c944b6a4d5b893cb3cc89a";
//        String question = "Fudan Univ, Obstet & Gynecol Hosp, Shanghai, Peoples R China";
//        String content = "请检查提供的文本中是否包含医院科室名称，并将其与已知的45个标准科室名称进行匹配。如果匹配成功，仅返回最相关的标准科室名称；如果有多个可能的匹配项，选择最接近的一个。若无任何科室名称匹配，则返回空字符串。以下是参考的标准科室名单： - 变态反应 - 病理科 - 耳鼻喉科 - 妇产科 - 罕见病 - 核医学 - 呼吸科 - 急诊医学 - 检验医学 - 结核病 - 精神医学 - 老年科 - 临床药学 - 麻醉科 - 内分泌 - 普通外科 - 肾脏病 - 疼痛学 - 消化病 - 小儿外科 - 心外科 - 血液学 - 整形外科 - 传染感染 - 超声医学 - 放射科 - 风湿病 - 骨科 - 健康管理 - 康复医学 - 口腔科 - 泌尿外科 - 皮肤科 - 全科医学 - 烧伤科 - 神经内科 - 神经外科 - 生殖医学 - 小儿内科 - 心血管病 - 胸外科 - 眼科 - 运动医疗 - 肿瘤学 - 重症医学 确保返回结果严格符合上述科室名称之一，或在无匹配情况时返回空字符串。";

//        String question = "TNF";
//        String content = "请检查提供的文本中是否是基因的名称，或者指代基因编码的产物或与基因调控有关的功能，如果是请先回答1，如果不是请先回答0，然后再解释原因。";

//        String question = "Xinxiang Medical University, Henan Collaborat Innovat Center Molecular Diagnosis & Laboratories Medical, Xinxiang, Henan, People's Republic of China";
//        String content = "请检查提供的文本中是否包含新乡医学院附属的医院或下属的部门名称，并将其与已知的51个标准附属医院或下属部门名称进行匹配。如果匹配成功，请返回英文翻译成中文的名称以及最相关的标准名称；如果有多个可能的匹配项，选择最接近的一个。若无任何名称匹配，则将英文翻译成中文后返回。以下是参考的标准名称名单：网络与信息中心 - 图书馆（档案馆） - 期刊社 - 临床医学学部 - 人文社会科学学部 - 药学学部 - 峻极书院 - 弘毅书院 - 基础医学院 - 公共卫生学院 - 药学院 - 医学技术学院 - 护理学院 - 卫生健康管理学院 - 法医学院 - 生命科学技术学院 - 心理学院 - 外语学院 - 医学工程学院 - 马克思主义学院 - 医学人文学院 - 体育学院 - 国际教育学院 - 继续教育学院 - 河南省心理咨询中心 - 河南省神经病学研究所 - 河南省科技期刊研究中心 - 健康中原研究院 - 新乡医学院结核病研究所 - 新乡医学院心血管疾病研究所 - 河南省高等医学教育发展研究中心 - 精神疾病中西医结合临床医学中心 - 新乡医学院组织工程与再生临床医学中心 - 河南省生物精神病学重点实验室 - 河南省医用组织再生重点实验室 - 河南省神经修复重点实验室 - 河南省免疫与靶向药物重点实验室 - 精神神经医学研究院 - 第一附属医院 - 第二附属医院 - 第三附属医院 - 附属中心医院 - 附属人民医院 - 附属濮阳市油田总医院 - 附属焦作市人民医院 - 附属濮阳市人民医院 - 附属濮阳市安阳地区医院 - 附属开封市中心医院 - 附属郑州市第一人民医院 - 附属郑州市第七人民医院 - 附属安阳市人民医院。返回数据的格式：{\"standardName\":\"\",\"translatedName\":\"\"}";

//        String question = "Department of Orthopaedic Surgery, University of Michigan, Ann Arbor, MI.";
//        String content = "任务说明：根据提供的文本内容，判断该文本是否明确指向某个特定国家。如果可以确定，请将该国家的名称用方括号[]标注后返回；如果无法从文本中确定具体的国家，则返回空。 执行步骤： 1. 仔细阅读并分析给定的文本。 2. 判断文本中是否存在足够的信息来唯一识别一个国家。 3. 如果能够确定国家身份，在结果中使用方括号[]包围该国名作为输出。 4. 若文本不足以确定具体是哪个国家或根本没有提到任何国家，则输出为空。 示例输入与预期输出： - 输入：“Department of Experimental Clinical and Health Psychology, Ghent University.” 因文本中没有明确的国家，但文本中含有“Ghent University”，再判断“Ghent University”在比利时，所以输出：[比利时] - 输入：“Departments of 2 Neurosurgery and.”因文本中完全无法判断属于哪个国家，所以输出：（空）。";

//        String question = "Zheng, C-P；Jinan University, Shenzhen Peoples Hospital, Department Otorhinolaryngol, Clinical Medical College 2, Shenzhen, People's Republic of China";
//        String content = "请根据提供的信息，匹配最符合条件的作者：[郑成波.深圳人民医院耳鼻喉科；郑沙普.深圳人民医院喉科]，如果可以匹配上，请返回符合条件的作者，如果不符合，请返回空。";

        // ["Hainan Medical University","Peoples Hospital Hainan Province 5"]
//        String question = "[\"Hainan Medical University\",\"Peoples Hospital Hainan Province 5\"]";
//        String content = "请根据提供的信息，判断最可能的医院的名称，如果可以准确的判断，请将中文名称使用方括号[]括住后返回，如果不能准确的判断是哪个，可以推荐多个，请将多个中文名称使用花括号{}括住后返回，如果不是一家医院，而是其它机构的名称，请将中文名称使用英文的引号\"\"引住后返回，如果根本就不是机构，请返回\"empty\"。";

//        String send = send(question, content);
//        System.out.println("--|" + send.replace(System.lineSeparator(), "----") + "|");

        //Hainan Medical University
        //海南医学院
        //
        //Peoples Hospital Hainan Province 5
        //海南省人民医院

        //CollUtil.join(aidList, ",")
//        List<String> enAuList = JSONObject.parseArray(question, String.class);
//
//        // 让其返回JSON格式，此只针对医院名称的判断。
//        String send = sendForJson(CollUtil.join(enAuList, ", "));
//        JSONArray objects = JSONObject.parseArray(send);
//        if (!objects.isEmpty()) {
//            for (Object object : objects) {
//                JSONObject jsonObject = JSONObject.parseObject(object.toString());
//                String unitName = jsonObject.getString("unitName");
//                String info = jsonObject.getString("info");
//                System.out.println(info);
//                System.out.println(unitName);
//                System.out.println();
//            }
//        }
//        String fuDan = "- 变态反应 - 病理科 - 耳鼻喉科 - 妇产科 - 罕见病 - 核医学 - 呼吸科 - 急诊医学 - 检验医学 - 结核病 - 精神医学 - 老年科 - 临床药学 - 麻醉科 - 内分泌 - 普通外科 - 肾脏病 - 疼痛学 - 消化病 - 小儿外科 - 心外科 - 血液学 - 整形外科 - 传染感染 - 超声医学 - 放射科 - 风湿病 - 骨科 - 健康管理 - 康复医学 - 口腔科 - 泌尿外科 - 皮肤科 - 全科医学 - 烧伤科 - 神经内科 - 神经外科 - 生殖医学 - 小儿内科 - 心血管病 - 胸外科 - 眼科 - 运动医疗 - 肿瘤学 - 重症医学";
//        String stem = " - 麻醉学 - 心血管病学 - 呼吸病学 - 结核病学 - 消化病学 - 血液病学 - 肾脏病学 - 内分泌病学与代谢病学 - 风湿病学与自体免疫病学 - 变态反应学 - 传染病学 - 普通外科学 - 神经外科学 - 超声医学 - 放射学 - 核医学 - 护理学 - 肿瘤学 - 急诊医学 - 危重症医学 - 精神病学 - 神经病学 - 皮肤病学 - 口腔医学 - 耳鼻喉科学 - 眼科学 - 儿科学 - 妇产科学 - 整形外科学 - 烧伤外科学 - 骨外科学 - 泌尿外科学 - 心血管外科学 - 胸外科学";
////        String user = "Bearer sk-c65ee8baf0c440238e51f74495107da3";
//
//        String sendForJson = sendFuDanJson("Department General Surgeons", stem, user);
//        System.out.println("sendForJson: " + sendForJson);
//        List<En.UnitInfo> unitInfoList = new ArrayList<>();
//        En.UnitInfo unitInfo = new En.UnitInfo();
//        Matcher unitMatcher = Pattern.compile("\"dept\"\\s*:\\s*\"([^\"]*)\"").matcher(sendForJson);
//        Matcher infoMatcher = Pattern.compile("\"info\"\\s*:\\s*\"([^\"]*)\"").matcher(sendForJson);
//        if (unitMatcher.find()) {
//            unitInfo.setUnit(unitMatcher.group(1).trim());
//        }
//        if (infoMatcher.find()) {
//            unitInfo.setInfo(infoMatcher.group(1).trim());
//        }
//        if (!unitInfo.getUnit().isEmpty() || !unitInfo.getInfo().isEmpty()) {
//            unitInfoList.add(unitInfo);
//        }
//        List<En.UnitInfo> unitInfoList = new ArrayList<>();
////        String sendForJson = TongYiApi.sendFuDanJson(question, fuDanOrStem, user);
//        JSONArray objects = JSONObject.parseArray(sendForJson);
//        if (!objects.isEmpty()) {
//            for (Object object : objects) {
//                JSONObject jsonObject = JSONObject.parseObject(object.toString());
//                String dept = jsonObject.getString("dept");
//                if (null != dept && dept.length() > 1) {
//                    En.UnitInfo unitInfo = new En.UnitInfo();
//                    unitInfo.setUnit(dept);
//                    unitInfo.setInfo(jsonObject.getString("info"));
//                    unitInfoList.add(unitInfo);
//                }
//            }
//        }
//        String upData = "";
//        if (unitInfoList.isEmpty()) {
////            upData = fuDan.isEmpty() ? "1" : upData;
////            upData = "1".equals(fuDan) ? "2" : upData;
////            upData = "2".equals(fuDan) ? "3" : upData;
////            upData = "3".equals(fuDan) ? "4" : upData;
////            upData = "4".equals(fuDan) ? "5" : upData;
////            upData = "5".equals(fuDan) ? "6" : upData;
//        } else {
//            upData = JSONUtil.toJsonStr(unitInfoList);
//        }
//        System.out.println("unitInfoList: " + unitInfoList);


//        Set<String> hospSet = CityList.hospSet();
//        Set<String> citySet = CityList.citySet();
        String question = "英文名称:\"shanghai fengxian district central hospital; shanghai jiao tong university; affiliated peoples hospital 6\"，中文名称:\"中国_上海交通大学\"";
        question = "英文名称:\"pudong new area peoples hospital\"，中文名称:\"中国_上海市浦东新区人民医院\"";
//        System.out.println(question);
//        String youDao = TransApi.youDaoEnToCnTrans(question);
//        System.out.println(youDao);
//        String hosps = Hosp.getHospSet(hospSet, youDao, citySet);
//        System.out.println(hosps);
//        String sendHospJson = TongYiApi.sendHospJson(question, user, hosps);
//        System.out.println("--" + sendHospJson);

//        String user = "Bearer sk-c65ee8baf0c440238e51f74495107da3";
//        String s = sendUnitNameJson(question, user);
        String s = sendSubjectJson("stanford university", user);

        System.out.println(s);

    }

    public static String api(String question, String user) {
//        System.out.println("question: " + question);
        List<MsgEntity> msgEntities = new ArrayList<>();
//        msgEntities.add(new MsgEntity("user", "请检查提供的文本中是否包含医院科室名称，并将其与已知的标准的科室名称进行匹配。如果匹配成功，仅返回最相关的标准科室名称；如果有多个可能的匹配项，选择最接近的一个。若无任何科室名称匹配，则推荐一个中文的科室名称，推荐的请在名称上加上英文的方括号。" +
//                "以下是参考的标准科室名单：" + dept + " ，返回数据为JSON格式，字段dept为匹配上的科室名称，info为输入的文本，返回格式要求:" +
//                "[{\"dept\":\"放射科\",\"info\":\"Radiology Department\"},{\"dept\":\"病理科\",\"info\":\"Pathology Department\"}]，需要匹配的文本是:" + question));
//        String str = "请检查提供的文本中是否包含医院科室名称，并将其与已知的标准的科室名称进行匹配。如果匹配成功，仅返回最相关的标准科室名称；如果有多个可能的匹配项，选择最接近的一个。若无任何科室名称匹配，则推荐一个中文的科室名称，推荐的请在名称上加上英文的方括号。" +
//                "以下是参考的标准科室名单：" + dept + " ，返回数据为JSON格式，字段dept为匹配上的科室名称，info为输入的文本，格式要求:" +
//                "[{\"dept\":\"放射科\",\"info\":\"Radiology Department\"},{\"dept\":\"病理科\",\"info\":\"Pathology Department\"}]，需要匹配的文本是:" + question;
//        System.out.println(str);
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("info_" + question);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String guideline(String question, String user) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        String send = "国际临床指南，一般都是有各国的卫生管理机构或行业学会，或者医疗行业的组织或部门编写的，比如署名信息为：\"ACC/AHA Representative\"的，是美国心脏病学会和美国心脏学会组织编写的，再比如：\"Centro Médico La Raza\"，这是一家位于墨西哥的医疗中心，是有可能起草或组织编写临床指南的。基于此常识，请问署名信息为：\"" + question + "\"的，" +
                "是否是一家有可能组织或起草国际临床指南的机构，如果是请回答是，如果不是，请回答不是，不管是或不是，均对提问的信息翻译成中文，返回格式要求是标准的JSON，格式要求: \"[{\"yn\":\"不是\",\"cnName\":\"西班牙_赫罗纳大学\"},{\"yn\":\"是\",\"cnName\":\"美国心脏病学会\"}]\")";
        msgEntities.add(new MsgEntity("user", send));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
//                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
//                    System.out.println("----question:" + question + " user:" + user);
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendSubjectJson(String question, String user) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        String send = "你通晓国家《研究生教育学科专业目录》的设置规则，学科门类共计14个，每个学科门类下又分为若干个一级学科，比如，历史学下又分为：考古学,中国史,世界史,博物馆四个一级学科，具体列表为：哲学(哲学,应用伦理); 经济学(理论经济学,应用经济学,金融,应用统计,税务,国际商务,保险,资产评估,数字经济); " +
                "法学(法学,政治学,社会学,民族学,马克思主义理论,公安学,中共党史党建学,纪检监察学,法律,社会工作,警务,知识产权,国际事务); 教育学(教育学,心理学,体育学,教育,体育,国际中文教育,应用心理); 文学(中国语言文学,外国语言文学,新闻传播学,翻译,新闻与传播,出版); 历史学(考古学,中国史,世界史,博物馆); " +
                "理学(数学,物理学,化学,天文学,地理学,大气科学,海洋科学,地球物理学,地质学,生物学,系统科学,科学技术史,生态学,统计学,气象); 工学(力学,机械工程,光学工程,仪器科学与技术,材料科学与工程,冶金工程,动力工程及工程热物理,电气工程,电子科学与技术,信息与通信工程,控制科学与工程,计算机科学与技术,建筑学," +
                "土木工程,水利工程,测绘科学与技术,化学工程与技术,地质资源与地质工程,矿业工程,石油与天然气工程,纺织科学与工程,轻工技术与工程,交通运输工程,船舶与海洋工程,航空宇航科学与技术,兵器科学与技术,核科学与技术,农业工程,林业工程,环境科学与工程,生物医学工程,食品科学与工程,城乡规划学,软件工程,生物工程," +
                "安全科学与工程,公安技术,网络空间安全,建筑,城乡规划,电子信息,机械,材料与化工,资源与环境,能源动力,土木水利,生物与医药,交通运输,风景园林); 农学(作物学,园艺学,农业资源与环境,植物保护,畜牧学,兽医学,林学,水产,草学,水土保持与荒漠化防治学,农业,兽医,林业,食品与营养); 医学(基础医学,临床医学," +
                "口腔医学,公共卫生与预防医学,中医学,中西医结合,药学,中药学,特种医学,护理学,法医学,公共卫生,护理,中药,中医,医学技术,针灸); 军事学(军事思想与军事历史,战略学,联合作战学,军兵种作战学,军队指挥学,军队政治工作学,军事后勤学,军事装备学,军事管理学,军事训练学,军事智能,联合作战指挥,军兵种作战指挥," +
                "作战指挥保障,战时政治工作,后勤与装备保障,军事训练与管理); 管理学(管理科学与工程,工商管理学,农林经济管理,公共管理学,信息资源管理,工商管理,公共管理,会计,旅游管理,图书情报,工程管理,审计); 艺术学(艺术学,音乐,舞蹈,戏剧与影视,戏曲与曲艺,美术与书法,设计); 交叉学科(集成电路科学与工程,国家安全学," +
                "设计学,遥感科学与技术,智能科学与技术,纳米科学与工程,区域国别学,文物,密码)。请根据此列表回答：" + question + "，应该归属到哪个一级学科？如果没有任何一个一级学科可以匹配上，请推荐一个，推荐的一级学科应使用中文，并加上英文的方括号，如果可以匹配上则不需要推荐，返回结果只能是一条。返回格式要求是" +
                "标准的JSON，具体为: [{\"subject\":\"土木工程\"},{\"subject\":\"[人工智能]\"}]。务请注意，返回的一定是一级学科，不能是学科门类，比如:\"医学\"是学科门类，\"临床医学\"是一级学科，返回时只能返回一级学科，而不能返回学科门类。";
        msgEntities.add(new MsgEntity("user", send));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
//                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
//                    System.out.println("----question:" + question + " user:" + user);
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendUnitNameJson(String question, String user) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        msgEntities.add(new MsgEntity("user", "你通晓世界各国各机构中英文名称的不同写法，比如，某机构英文名称为:\"zhejiang university, jinhua hospital\"，中文名称为:\"中国_金华市中心医院\"，那么，这两个不同的名称是指的同一家机构吗？虽然，从字面意思上来理解，不是指的同一家机构，但经查询该机构的相关资料，发现是指的同一家机构。" +
                "请按此思路再来分析" + question + "，这两个不同写法的机构是指的同一家机构吗？如果是，请回答是，如果不是，请根据英文名称推荐一个中文的机构名称，推荐的应在机构名称前面加上国家。返回格式要求是标准的JSON，格式要求:" + "[{\"yn\":\"不是\",\"recommend\":\"西班牙_赫罗纳大学\"},{\"yn\":\"是\",\"recommend\":\"\"}]"));
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
//                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
//                    System.out.println("----question:" + question + " user:" + user);
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendUnitJson(String question, String user) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        msgEntities.add(new MsgEntity("user", "请根据描述单位名称的文本，推荐一个准确的中文的单位名称，返回数据格式为JSON，字段unit为推荐的中文单位名称，info为输入的文本，格式要求:" +
                "[{\"unit\":\"山东省立医院\",\"info\":\"Shandong Provincial Hospital\"},{\"unit\":\"山东大学齐鲁医院\",\"info\":\"Shandong University QILU Hospital\"}]，需要匹配的文本是:" + question));
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
//                        System.out.println("info_" + question);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendFuDanJson(String question, String dept, String user) {
//        System.out.println("question: " + question);
        List<MsgEntity> msgEntities = new ArrayList<>();
        msgEntities.add(new MsgEntity("user", "请检查提供的文本中是否包含医院科室名称，并将其与已知的标准的科室名称进行匹配。如果匹配成功，仅返回最相关的标准科室名称；如果有多个可能的匹配项，选择最接近的一个。若无任何科室名称匹配，则推荐一个中文的科室名称，推荐的请在名称上加上英文的方括号。" +
                "以下是参考的标准科室名单：" + dept + " ，返回数据为JSON格式，字段dept为匹配上的科室名称，info为输入的文本，返回格式要求:" +
                "[{\"dept\":\"放射科\",\"info\":\"Radiology Department\"},{\"dept\":\"病理科\",\"info\":\"Pathology Department\"}]，需要匹配的文本是:" + question));
//        String str = "请检查提供的文本中是否包含医院科室名称，并将其与已知的标准的科室名称进行匹配。如果匹配成功，仅返回最相关的标准科室名称；如果有多个可能的匹配项，选择最接近的一个。若无任何科室名称匹配，则推荐一个中文的科室名称，推荐的请在名称上加上英文的方括号。" +
//                "以下是参考的标准科室名单：" + dept + " ，返回数据为JSON格式，字段dept为匹配上的科室名称，info为输入的文本，格式要求:" +
//                "[{\"dept\":\"放射科\",\"info\":\"Radiology Department\"},{\"dept\":\"病理科\",\"info\":\"Pathology Department\"}]，需要匹配的文本是:" + question;
//        System.out.println(str);
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("info_" + question);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendDoubao(String content, String question) {
        // 这个是豆包的模型
        ArkService service = ArkService.builder()
                .ak("AKLTZjk2ZjA3NGQxYTEyNGFkOTk4ZDljNmFlMjJhMGU0M2Q")
                .sk("Tm1SalpqQTNZakJqWkRrM05ERmhOVGszWkRNNVpHRmlOamd6TTJVMll6RQ==")
                .baseUrl("https://ark.cn-beijing.volces.com/api/v3/")
                .region("cn-beijing").build();

        System.out.println("\n----- standard request -----");
        final List<ChatMessage> messages = new ArrayList<>();
        final ChatMessage systemMessage = ChatMessage.builder().role(ChatMessageRole.SYSTEM).content(content).build();
        final ChatMessage userMessage = ChatMessage.builder().role(ChatMessageRole.USER).content(question).build();
        messages.add(systemMessage);
        messages.add(userMessage);

        ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
                .model("ep-20241213092127-qvpk6")
                .messages(messages)
                .build();

        List<String> list = new ArrayList<>();
        service.createChatCompletion(chatCompletionRequest).getChoices().forEach(choice -> list.add((String) choice.getMessage().getContent()));


        // shutdown service
        service.shutdownExecutor();
        return list.get(0);
    }

    public static String send(String question, String txt) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        msgEntities.add(new MsgEntity("system", txt));
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendMsg(msgEntities);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {

            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
//                        System.out.println("info_" + question);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static String sendHospJson(String question, String user, String hosps) {
        List<MsgEntity> msgEntities = new ArrayList<>();
        msgEntities.add(new MsgEntity("user", "请根据提供的医院名称列表:" + hosps + "，与需要匹配的文本信息进行比对，返回一个准确的医院名称，字段unit为匹配上的准确的医院名称，如果匹配不到准确的医院名称，请推荐一个准确的中文医院名称，并加上英文方括号，info为输入的文本，返回数据为JSON，格式要求:" +
                "[{\"unit\":\"山东省立医院\",\"info\":\"Shandong Provincial Hospital\"},{\"unit\":\"山东大学齐鲁医院\",\"info\":\"Shandong University QILU Hospital\"}]，需要匹配的文本是:" + question));
        msgEntities.add(new MsgEntity("user", question));
        OkHttpClient client = new OkHttpClient().newBuilder()
                .connectTimeout(100, java.util.concurrent.TimeUnit.SECONDS)
                .readTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .writeTimeout(1000, java.util.concurrent.TimeUnit.SECONDS)
                .build();
        Request request = sendWithJson(msgEntities, user);
        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
        StringBuilder stringBuilder = new StringBuilder();
        if (null != response) {
            ResponseBody responseBody = response.body();
            if (null != responseBody) {
                InputStream inputStream = responseBody.byteStream();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
//                        System.out.println("BAOCUO__" + line);
//                        System.out.println("info_" + question);
                        if ("[DONE]".equals(line) || "data: [DONE]".equals(line)) {
                            break;
                        }
                        line = line.replaceAll("data: ", "").trim();
                        try {
                            if (isNotNull(line)) {
                                ChatCompletionChunk chatCompletionChunk = JSONObject.parseObject(line, ChatCompletionChunk.class);
                                List<Choice> choices = chatCompletionChunk.getChoices();
                                for (Choice choice : choices) {
                                    String content = choice.getDelta().getContent().replaceAll("\n\n", "\n");
                                    stringBuilder.append(content);
                                }
                            }
                        } catch (Exception e) {
                            System.out.println("BAOCUO__" + line);
//                            e.printStackTrace(System.err);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace(System.err);
                }
            }
        }
        return stringBuilder.toString();
    }

    public static Request sendWithJson(List<MsgEntity> msgEntities, String user) {
        String string = "{\n" +
                "    \"messages\": " + JSONObject.toJSONString(msgEntities) +
                "      ,\n" +
                "    \"model\": \"qwen-plus-latest\",\n" +
                "    \"response_format\": {\n" +
                "        \"type\": \"json_object\"\n" +
                "    },\n" +
                "    \"frequency_penalty\": 0,\n" +
                "    \"max_tokens\": 4000,\n" +
                "    \"presence_penalty\": 0,\n" +
                "    \"stop\": null,\n" +
                "    \"stream\": true,\n" +
                "    \"temperature\": 1,\n" +
                "    \"enable_search\": true,\n" +
                "    \"top_p\": 0.9\n" +
                "}";
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType, string);
        return new Request.Builder().url("https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions")
                .method("POST", body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                // "Bearer sk-c65ee8baf0c440238e51f74495107da3"
                .addHeader("Authorization", user)
                .build();
    }

    public static Request sendMsg(List<MsgEntity> msgEntities) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("messages", JSONObject.toJSONString(msgEntities));
        map.put("model", "\"qwen-long\"");
        map.put("frequency_penalty", 0);
        map.put("max_tokens", 2000);
        map.put("presence_penalty", 0);
        map.put("stop", null);
        map.put("stream", true);
        map.put("temperature", 1);
        map.put("top_p", 0.9);
        String string = mapToString(map);
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType, string);
        Request request = new Request.Builder().url("https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions")
                .method("POST", body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .addHeader("Authorization", "Bearer sk-c65ee8baf0c440238e51f74495107da3")
                .build();
        return request;
    }

    public static String mapToString(Map<String, Object> map) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            if (stringBuilder.length() > 1) { // 避免第一个元素前出现逗号
                stringBuilder.append(",");
            }
            String key = entry.getKey();
            Object value = entry.getValue();
            stringBuilder.append("\"").append(key).append("\":").append(value);
        }
        stringBuilder.append("}");
        return stringBuilder.toString();
    }

    public static boolean isNotNull(String str) {
        return str != null && !str.trim().isEmpty() && !"null".equals(str);
    }

    @Data
    public static class ChatCompletionChunk {
        private String id;
        private List<Choice> choices;
        private long created;
        private String model;
        private String system_fingerprint; // 由于示例中为null，这里使用Object类型
        private String object;
    }

    @Data
    public static class Choice {
        private int index;
        private Delta delta;
        private Object finish_reason; // 由于示例中为null，这里使用Object类型
        private Object logprobs;
    }

    @Data
    public static class Delta {
        private String content;
        private String role;
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Accessors(chain = true)
    public static class MsgEntity {
        private String role;
        private String content;
    }
}


